[第4波]幽魂系列汉化的有关资料

shane007

6 m: Z% z- e7 b9 x( c, T最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
也许将来可以用于汉化。
# e& t$ s8 }3 s& ?" T
6 M. s1 x1 c8 W' B$ ?+ A. @/ a和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html

( x0 y2 p# m' I3 Z. o相关工具
2 j; K! y7 d; v; O1 r9 c) Rhttp://anthonylarme.tripod.com/phantas/phcheats.html
0 D& k0 K# c3 F* ?1 ]-----------------------------------------------------------------------
' T* a. |" Q" r: {$ p9 x2012/1/2  更新
关于幽魂游戏的字幕
0 u0 ^& L' [: S5 pPhantasmagoria subtitles function discovered - ScummVM :: Forums

" C& I# u# y: `$ U" ?- XVMD文件
Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki

字幕
; f* g3 N4 O: R( O8 _5 ^Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)
1 b' b* t/ y) l# N# `# @  n
FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

1. /*
   # ?" m- v# }6 X( f) e8 H$ K
2. * subtitle-rbt.c
   
3. *  by Mike Melanson (mike -at- multimedia.cx)
   9 q* K3 F6 m/ y' p: v1 M9 [
4. *
   , }% J" I4 l! r8 G9 f) R5 S& F
5. * build with this command:
   
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   0 ~4 ?4 m. I! c* _, r
7. */
   
8. 
   & `/ Z8 S: a% B1 A/ u' O( I) s
9. #include <inttypes.h>
   
10. #include <math.h>
    5 G9 p, d0 {! K/ t
11. #include <stdio.h>
    - }8 _) o: e/ U, C3 @
12. #include <stdlib.h>
    2 u& k# D7 J) I% F/ V
13. #include <string.h>
    5 C; K3 t& K5 O* d
14. 
    
15. #include <ass/ass.h>
    
16. 
    
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    
18. 
    
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    9 H; ]8 \: Q2 f2 M+ Y$ K
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    
23. 
    - P- h5 Z/ [6 h: h* _2 b! d7 N
24. /*********************************************************************/
    
25. 
    * Q9 m3 v" \" `# a, a* A
26. /* Bit reader stuff */
    
27. 
    
28. typedef struct
    - D$ t: c0 Q8 n* s+ o% ]7 v4 j
29. {
    
30.     uint8_t *bytestream;
      Q8 ?% u  m# I" Z! @' K/ t
31.     int bytestream_size;
    ' A5 L2 \8 \0 o8 M
32.     int index;
    
33.     uint32_t bits;
    0 d( d$ R- b" J! E
34.     int bits_in_buffer;
    
35. } get_bits_context;
    
36. 
    
37. static inline void reload_bits(get_bits_context *gb)
    
38. {
    0 n$ l) Z1 t6 ?" g7 S' I
39.     while (gb->bits_in_buffer <= 24)
    
40.     {
    
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    ' m8 c2 W8 y. m7 T6 T
43.         gb->bits_in_buffer += 8;
      C' M' Z4 C* |1 [+ A
44.     }
    
45. }
    
46. 
    ) V8 Q1 b- C; S7 Z( G5 Z" U( d' L
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    
48. {
    # L' {; q# S* _7 {8 T$ O6 m
49.     gb->bytestream = malloc(size);
    
50.     memcpy(gb->bytestream, bytestream, size);
    
51.     gb->bytestream_size = size;
    
52.     gb->index = 0;
    / x: Q  U9 @" `9 ^" A
53.     gb->bits = 0;
    
54.     gb->bits_in_buffer = 0;
    # M) M2 y. h) _% [" L3 W" w5 s5 t
55. 
    0 R4 y/ c8 a9 o0 Z1 R/ v: z6 J8 X. {) x
56.     reload_bits(gb);
    
57. }
    
58. 
    
59. /* read bits without consuming them from the stream */
    6 U6 x5 a" V. ?, l$ `8 A
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    
62.     if (count >= 24)
    
63.         return -1;
    3 B- Z. \$ b6 _# s+ |3 `
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    7 s: t# z' p& B/ P/ W
66.     return (gb->bits >> (32 - count));
    6 [: ], G0 k: K0 B% j- e
67. }
    & {# l  @- z: ?; {( ~5 U; t
68. 
    ( N5 b" V5 p/ t; n" u# Y' ]
69. /* read and consume bits from the stream */
    + a4 A( H# {) Q- G: o1 p8 m" g
70. static int read_bits(get_bits_context *gb, int count)
    
71. {
    0 B. i8 A" \4 T" J/ L
72.     int value;
    / p9 m2 F* {+ ]5 |
73. 
    , Z3 m; }* |+ [4 Y2 F
74.     if (count >= 24)
    
75.         return -1;
    
76. 
    5 X9 ?9 Z, I/ Q
77.     value = view_bits(gb, count);
    
78.     gb->bits <<= count;
    
79.     gb->bits_in_buffer -= count;
    & |" z. {; I& H% e( F( m( d$ _& t
80. 
    
81.     return value;
    
82. }
    ; j) u: {: T* k9 w0 G
83. 
    ! x% x7 n- V7 y. ~8 v' p
84. static void delete_get_bits(get_bits_context *gb)
    6 U" h; k' n) f3 F6 A. G
85. {
    % M/ E  V' D' \" r& M& W* A
86.     free(gb->bytestream);
    
87. }
    2 d7 K; ]6 V$ E( t. X3 t! o5 j
88. 
    ; C  _* Q/ L. h1 c3 J+ w
89. /*********************************************************************/
    / C- g9 a2 l# S1 H
90. 
    
91. /* Bit writer stuff */
    
92. 
    
93. #define MAX_PUT_BITS_BYTES 63000
    4 _3 ^" Z" ~: q8 T$ _/ k6 ^1 d
94. typedef struct
    . m5 f& L, S, a! N0 W8 G. U1 K' q
95. {
    8 o" D5 l* ^1 _4 ~" O% N
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    
97.     int byte_index;
    
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
    # x  k* T4 C# M& b2 n: O
100. } put_bits_context;
     , x1 }$ ?+ i* [) c, y
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     3 q  @! M& r3 s# E  g! r
103. {
     , n4 S) `2 h0 v4 M
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     1 S. e9 [0 \: t" N: j
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     / l8 x! K9 A( h1 C6 }' i' W$ [
107.     pb->bits_buffered = 0;
     
108. }
     8 Y& |6 E% D7 V
109. 
     
110. static put_bits_context *init_put_bits()
     0 k2 z/ u8 {8 ]2 |7 d9 [
111. {
     * F5 e$ W0 x4 Z2 E  M' O3 p
112.     put_bits_context *pb;
     
113. 
     
114.     pb = malloc(sizeof(put_bits_context));
     # {' C, {% n0 p. X& O# D1 G' i- t
115.     reset_put_bits(pb);
     
116. 
     1 }# \9 a  {$ z6 U0 c: O0 z
117.     return pb;
     
118. }
     8 m" c* N  b, x- O8 k6 ^
119. 
     . C6 S4 J- N( x# t$ B
120. static void put_bits(put_bits_context *pb, int bits, int count)
     
121. {
     7 u# t- x( T6 x4 f3 ]
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     
124.     pb->bits_buffered += count;
     
125. 
     & O3 \1 W9 _: |$ i* x( `8 V
126.     while (pb->bits_buffered >= 8)
     # e  y! t9 R" ^; ?6 {* T* h4 `: d' P( v
127.     {
     % V, _# E- Q/ I
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     ) d  u0 v3 W" h. O: a
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
     
131.     }
     
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     
134.     {
     
135.         printf("HELP! Bit overflow\n");
     / N! n' P, M& K
136.         exit(1);
     / v. q0 z, O0 j9 L2 T
137.     }
     . L2 S6 U6 p$ C/ l2 Z8 y. |0 t$ _4 |
138. }
     
139. 
     
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     
142.     if (pb->bits_buffered > 0)
     2 U3 [5 J/ N/ p$ C/ i+ F8 D
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     3 u) y1 k5 r% r! S3 h! M
144. }
     5 E  Y" A4 T+ z, N
145. 
     
146. static void delete_put_bits(put_bits_context *pb)
     
147. {
     
148.     free(pb->bytes);
     
149. }
     1 ~# h, h+ [- N, U: j/ u9 Z7 Y1 L
150. 
     5 i- V6 d( n8 N4 R1 |" @8 n1 y+ J; ~
151. /*********************************************************************/
     % \  _" v4 V% l! Z6 G, Z
152. 
     
153. /* RBT functions */
     
154. 
     9 M/ B! S# `6 p
155. #define PALETTE_COUNT 256
     2 T- W" U* H4 ]1 i# B: V3 R* b6 W
156. #define RBT_HEADER_SIZE 60
     
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     
158. #define SUBTITLE_THRESHOLD 0x70
     ' H# u; r: }( e7 Z% c  m( a2 a4 N* ]
159. #define MILLISECONDS_PER_FRAME 100
     
160. 
     
161. /* VLC table */
     0 o- h5 [4 H4 q# L# k4 F$ z1 V) @
162. #define VLC_SIZE 4
     
163. static struct
     
164. {
     
165.     int count;
     
166.     int value;
     
167. } lzs_vlc_table[] =
     
168. {
     
169.     /* code length = 2 bits; value = 2 */
     / n  K+ E7 [! p) S' d/ }' Z
170.     /* 0000 */ { 2, 2 },
     
171.     /* 0001 */ { 2, 2 },
     ( X# N  J1 q: [9 @& u8 w/ r8 C: M6 _
172.     /* 0010 */ { 2, 2 },
     1 B; b4 Q9 W, [6 y* B4 z
173.     /* 0011 */ { 2, 2 },
     
174. 
     
175.     /* code length = 2 bits; value = 3 */
     
176.     /* 0100 */ { 2, 3 },
     . C& w9 W5 z5 V  @! E
177.     /* 0101 */ { 2, 3 },
     
178.     /* 0110 */ { 2, 3 },
     
179.     /* 0111 */ { 2, 3 },
     4 v# h6 b* C8 a7 K
180. 
     ; a8 a7 q) p; g9 ?
181.     /* code length = 2 bits; value = 4 */
     : h  s: a9 u4 x. ^9 P2 z
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     
184.     /* 1010 */ { 2, 4 },
     
185.     /* 1011 */ { 2, 4 },
     
186. 
     
187.     /* code length = 4 bits; value = 5 */
     
188.     /* 1100 */ { 4, 5 },
     
189. 
     
190.     /* code length = 4 bits; value = 6 */
     , ]" J# G; u! w, N0 ^& C
191.     /* 1101 */ { 4, 6 },
     
192. 
     2 {: A  S; h: W7 A  Q3 Q
193.     /* code length = 4 bits; value = 7 */
     
194.     /* 1110 */ { 4, 7 },
     8 H# @+ T% f5 T: {
195. 
     ; ~9 W' p  f4 {' h5 d7 \
196.     /* special case */
     ; w, x0 m5 F6 M& P  Y8 m; I
197.     /* 1111 */ { 4, 8 }
     
198. };
     
199. 
       Q# N+ L# s, u& S$ F2 S! ?( P6 y
200. typedef struct
     7 L' _" m+ S3 {' T/ {6 a
201. {
     9 H! H% ~& M3 A1 e* A0 Y0 g+ o
202.     int version;
     
203.     int width;
     
204.     int height;
     
205.     int frame_count;
     
206.     int audio_chunk_size;
     
207.     uint8_t palette[PALETTE_COUNT * 3];
     
208.     off_t video_frame_size_table_offset;
     3 H9 P/ g: ]7 U0 U- m) ^2 v
209.     uint8_t *video_frame_size_table;
     
210.     off_t frame_size_table_offset;
     
211.     uint8_t *frame_size_table;
     7 m4 H2 p! |  l( e$ X
212.     uint8_t *frame_load_buffer;
     5 V& x! T/ I2 J2 F
213.     int dump_frames;
     
214. 
     1 W, _0 n) i: o+ o) S
215.     /* subtitle library */
     
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
     
218.     ASS_Track *ass_track;
     ! d" G; F+ J: v+ z: ]1 o+ d/ V6 _
219. } rbt_dec_context;
     " g3 z9 _5 W1 Y1 ]. Q
220. 
     " B; x' M7 W" M
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     
222.     uint8_t *image, int width, int height)
     # D' U0 B& r4 G) A2 K& w, d& I. f. s: c
223. {
     + q0 s& r/ i3 R: ^9 h' v9 ?9 T1 g
224.     FILE *outfile;
     ; ]/ l  ^& x7 O; l# R3 \7 ?
225.     uint8_t bytes[3];
     / @" c, z3 {  g( T, w
226.     int p;
     8 y  y* @6 [1 M4 D4 F# U- C) Y$ |
227.     uint8_t pixel;
     " O' H) G$ A! T! m; W
228. 
     
229.     outfile = fopen(filename, "wb");
     5 I  E- H: e/ [; c4 e7 \0 t6 u
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     8 e' C% \3 I+ b7 X, g. _
231.     for (p = 0; p < width * height; p++)
     
232.     {
     ' f9 l8 p7 {- ~5 L# e6 w
233.         pixel = image[p];
     1 V: U% ?# q; }3 c  H
234.         bytes[0] = rbt->palette[pixel*3+0];
     ) r' Q3 U7 _% g/ A
235.         bytes[1] = rbt->palette[pixel*3+1];
     / C/ C  J! b: `# O( g6 A% Y
236.         bytes[2] = rbt->palette[pixel*3+2];
     
237.         fwrite(bytes, 3, 1, outfile);
     $ F9 V2 U$ V7 F( _+ `( G& U7 k
238.     }
     
239.     fclose(outfile);
     
240. }
     
241. 
     
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     
243. {
     , l+ F0 r8 K/ p
244.     uint8_t header[RBT_HEADER_SIZE];
     . y1 F. @- H8 [6 l1 t# E* p
245.     int palette_data_size;
     - U4 {2 f- D  b' r8 P# l4 p; k
246.     uint8_t *palette_chunk;
     3 l- Z2 k; }& I. i: ^
247.     int unknown_chunk_size;
     
248.     uint8_t *unknown_chunk;
     ' H' x, [/ n, w* p$ o$ \8 }8 ^" M
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     ; x" b4 n1 C9 \
250.     off_t padding_size;
     / ?% a( k( n, y( y8 ]! @& @! m& z
251.     uint8_t *padding;
     
252.     int i;
     
253.     int frame_size;
     : Q) V+ p4 K/ s% [) O% ~. y
254.     int max_frame_size;
     . X" m$ b1 N. J! c
255.     int first_palette_index;
     
256.     int palette_count;
     
257.     int palette_type;
     0 X, V6 _- F* ^* o1 g4 \9 k7 J6 Z
258.     int palette_index;
     
259. 
     1 Q7 X+ e0 I5 a7 q/ a: a4 G7 V
260.     fseek(inrbt_file, 0, SEEK_SET);
       b3 i4 u5 M& w% |' K& U
261.     fseek(outrbt_file, 0, SEEK_SET);
     # v3 F1 i, y! V3 K
262. 
     
263.     /* load the header */
     % M9 f: t9 o/ [1 [! J6 d1 }) \
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     
265.     {
     
266.         printf("problem reading initial RBT header\n");
     
267.         return 0;
     
268.     }
     
269. 
     / D7 ]; A- F6 g1 \; ^' w; B1 V) @) S
270.     /* copy header to the output */
     6 b& d1 T( V( a+ i
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     ; i' t1 Y/ _) G5 e2 ?9 ]6 D
272.     {
     
273.         printf("problem writing initial RBT header\n");
     
274.         return 0;
     - [* h! ?! G/ ]7 B: [% _* o
275.     }
     
276. 
     
277.     rbt->version = LE_16(&header[6]);
     , t% U3 p/ U, Q4 |
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     
279.     rbt->frame_count = LE_16(&header[14]);
       Y9 q; T5 [1 S! R/ U5 x5 L+ f$ o0 Z
280. 
     2 h: ]$ I( K5 X+ ]* q; E
281.     /* transfer the unknown data, if it's there */
     
282.     unknown_chunk_size = LE_16(&header[18]);
     
283.     if (unknown_chunk_size > 0)
     
284.     {
     
285.         unknown_chunk = malloc(unknown_chunk_size);
     ; s* i, g1 @0 k& t
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     6 T5 m! X) T+ x8 A. j# m& T! I! a5 `
287.         {
     6 F" }  C# ]6 [% @7 x
288.             printf("problem reading unknown data\n");
     
289.             return 0;
     ( t4 _2 y5 [: g/ z: q* v
290.         }
     
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     / E) q5 F. C8 V7 x7 J
292.         {
     
293.             printf("problem writing unknown data\n");
     
294.             return 0;
     * e+ m7 L  K+ C- ]" U* a
295.         }
     
296.         free(unknown_chunk);
     $ d% q' m1 M# d9 @
297.     }
     
298. 
     7 [; a6 ]6 C* l! E: ^% {1 i
299.     /* transfer the palette chunk */
     & x% v: i) W" }; q
300.     palette_data_size = LE_16(&header[16]);
     
301.     palette_chunk = malloc(palette_data_size);
     
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     3 {; V5 Z/ B- Q% _
303.     {
     / ?' ?% D' b7 E0 ?
304.         printf("problem reading palette\n");
     
305.         return 0;
     
306.     }
     
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     3 b  a; R+ @, L  _6 }( F
308.     {
     8 M' M# ]! L$ c* `9 }' N
309.         printf("problem writing palette\n");
     ' Z" R8 r" y1 J1 E5 q/ I2 r- z4 {# G
310.         return 0;
     2 ^4 V2 x7 i! ~6 i! s2 K
311.     }
     
312.     /* load the palette into the internal context */
     0 B+ r6 ?4 ^5 a! T) @
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     4 s; H5 x  u. a1 }3 z# F
314.     first_palette_index = palette_chunk[25];
     
315.     palette_count = LE_16(&palette_chunk[29]);
     6 f9 o- J% X" X% L; G: ]& X& B
316.     palette_type = palette_chunk[32];
     " g( f( n  O4 R' {& p
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     - c2 p6 b' `+ g% @# x! V! o
319.     {
     " _# s8 m) x+ ~- k& J
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     " u9 M( F3 \0 c' }* [% F2 n
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     
323.     }
     # C2 X% C  H  l. s; B8 Z
324.     free(palette_chunk);
     
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     % @; U; T5 |9 P) y& x. @
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     ; c$ ?3 ~5 h, n
329.     {
     
330.         printf("problem reading frame table\n");
     
331.         return 0;
     
332.     }
     
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     ; p3 J9 {+ u' C/ ?
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
335.     {
     : p" c. I& U; u6 q: A
336.         printf("problem writing frame table\n");
     # ~' q) b* q* c! m- [
337.         return 0;
     
338.     }
     
339. 
     
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     ; J5 d% R# O" R/ ~% R; m, ^
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     # b4 T- M5 T- A. q
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     ) C3 C% h# _" e; p# K8 A
343.     {
     : I2 M; K- s) X8 Q
344.         printf("problem reading frame table\n");
     
345.         return 0;
     - f! m7 M! m' T# x0 N: N* \- A
346.     }
     
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     1 d  R6 l8 J/ |
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     : v8 I+ e% h" ?& }
349.     {
     ' L3 A4 h2 L  j6 t* G6 Z6 ?
350.         printf("problem writing frame table\n");
     
351.         return 0;
     
352.     }
     * @# H% t5 s& K4 r9 ~' o
353. 
     
354.     /* find the max frame size */
     9 s* {8 @6 ]9 H, A8 p
355.     max_frame_size = 0;
     + x( Q- e) Q5 k: |5 l0 w
356.     for (i = 0; i < rbt->frame_count; i++)
     
357.     {
     
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
359.         if (frame_size > max_frame_size)
     * s) ?3 e# f) M/ F1 F
360.             max_frame_size = frame_size;
     / X4 o. o9 q% l( j5 C" ]
361.     }
     
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     " R: _' t; ]" L' |6 H/ `; }  D3 S
363. 
     7 [! A+ P' P% X- b* ?3 a  ^$ Z' O
364.     /* transfer the unknown table(s) */
     
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     3 _/ u* f; ~' e3 P0 T, {, E
366.     {
     
367.         printf("problem reading unknown table\n");
     0 z7 {' K& ~) N' y
368.         return 0;
     . T1 }' x- i8 |0 R6 a
369.     }
     - g, z- @/ F  M3 n' d  \
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     , s9 n- L5 r0 R- c: `. @& h5 k
371.     {
     ) G! {5 w( O5 }( L; ~9 t
372.         printf("problem writing unknown table\n");
     9 S0 t$ J9 ^6 W1 t  k0 F
373.         return 0;
     
374.     }
     0 q# h8 T9 W8 H% ~
375. 
       K7 h# r5 X8 F
376.     /* copy over padding */
     
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     " r  Z* t! b% Y- R
378.     if (padding_size)
     
379.     {
     2 \; _' q+ B3 P+ J6 e
380.         padding = malloc(padding_size);
     ' O1 n; c+ T3 M# I
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     ! u+ B" V  |5 |2 s
382.         {
     
383.             printf("problem reading padding\n");
     
384.             return 0;
     
385.         }
       \6 Q& }, l( a6 W: y, A
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     * H" ?& }& T" b1 j, l3 L6 {5 [
387.         {
     5 h& j( ?) Z+ y# q9 f! H9 q
388.             printf("problem writing padding\n");
     1 r/ p+ a% Y" t/ \1 a/ \
389.             return 0;
     
390.         }
     
391.         free(padding);
     : C% i7 }% ?; ^$ z' \
392.     }
     : h2 O/ K+ _' H7 ?& I! o* E3 U7 e
393. 
     
394.     return 1;
     
395. }
       h4 j/ `( ?1 v+ u' ^
396. 
     . ^% y# |9 I, R
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     
399.     int vlc;
     0 ~1 O  T7 ?+ ^; Q' @* X! k: B$ s% y* B
400.     int count;
     
401.     int value;
     
402. 
     
403.     vlc = view_bits(gb, VLC_SIZE);
     
404.     count = lzs_vlc_table[vlc].count;
     . @! |- t: m# }! R' m9 l  ^
405.     value = lzs_vlc_table[vlc].value;
     , H+ _7 H8 c7 q0 g
406. 
     
407.     read_bits(gb, count);
     
408.     if (value == 8)
     
409.     {
     
410.         do
     
411.         {
     
412.             vlc = read_bits(gb, VLC_SIZE);
     % T( M* R. T& }2 w3 w( Q
413.             value += vlc;
     
414.         }
     
415.         while (vlc == 0xF);
     " W- u' k+ Q/ S, q& j, g
416.     }
     
417. 
     ! \! |- ?3 K6 @* G
418.     return value;
     
419. }
     ! V, q" V( t3 Q- T1 T& I! S  p/ a
420. 
     
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     7 C7 h( z( P7 X3 E7 r1 v
422.     int full_window_stride,
     
423.     int window_top, int window_bottom, int window_left, int window_right)
     
424. {
     
425.     int last_pixel;
     + b* u7 {7 K1 w9 K
426.     int run_size;
     1 Z2 P0 E4 @* `4 s$ |  F, W
427.     int x;
     
428.     int y;
     
429.     int start_index;
     % L, |! A. Q) P+ r, D
430.     int end_index;
     
431.     int encode_last_run;
     
432. 
     ' D  o- ?& D7 T* e2 m* S2 v
433.     last_pixel = full_window[0];
     
434.     run_size = 1;
     
435.     for (y = window_top; y <= window_bottom; y++)
     # ?' R; q- K, G% L; Q* ]7 |
436.     {
     8 T+ R+ _1 w) T& A7 O
437.         start_index = y * full_window_stride + window_left;
     & M. u% z- l& Z. K
438.         if (y == window_top)
     
439.             start_index += 1;
     
440.         end_index = y * full_window_stride + window_right;
     5 d; j; `" Q, G
441.         if (y == window_bottom)
     ' o0 U8 V9 _# G% n! k7 J/ {! S
442.             encode_last_run = 1;
       t: G; M5 D/ k" f3 B
443.         else
     : c5 V; U$ j3 V) h  v
444.             encode_last_run = 0;
     ! W4 y; m; a4 i7 L
445.         for (x = start_index; x < end_index; x++)
     
446.         {
     % n9 w( D% H4 T6 {/ O+ H2 r- A# c. Q
447.             if (!encode_last_run && full_window[x] == last_pixel)
     
448.                 run_size++;
     % N8 V2 f( p# Q* v  P& O
449.             else
     ( T2 e/ \* e' T1 H) W7 x
450.             {
     + Y/ @; L+ p0 R6 e; c
451.                 if (run_size == 1)
     ) E+ L5 r: E" X0 x2 @6 V
452.                 {
     / D9 ]8 U4 ^# g* n! p; x0 D( l
453.                     /* encode a 0 bit followed by raw pixel byte */
     : ]8 C6 p. N2 P4 ]: G# U. ^1 w, b
454.                     put_bits(pb, 0, 1);
     ; Y/ A* I. x2 H! R$ o+ R
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     
457.                 else if (run_size == 2)
     / e# {' O7 Q3 V4 v. D
458.                 {
     
459.                     /* encode a 0 bit followed by raw pixel byte */
     % [  p6 b* o7 e) V0 P
460.                     put_bits(pb, 0, 1);
     & E% S5 j( e/ x. U
461.                     put_bits(pb, last_pixel, 8);
     ! ~+ ?. ~2 [2 Y! Y$ \
462.                     put_bits(pb, 0, 1);
     
463.                     put_bits(pb, last_pixel, 8);
     
464.                 }
     . M' ~& v* H- N3 ?& L
465.                 else
     
466.                 {
     
467.                     /* encode a 0 bit followed by raw pixel byte */
     
468.                     put_bits(pb, 0, 1);
     
469.                     put_bits(pb, last_pixel, 8);
     , r) ]. Z1 z% P1 S* t9 s
470.                     run_size--;
     
471.                     /* encode a run: a 1 bit, followed by a back reference
     - ^; c0 o  Q' f% K, K
472.                      * offset (-1), followed by a length */
     3 h" |( O1 i- P! t1 T" o
473.                     put_bits(pb, 1, 1);
     
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     2 r% o% e: @# a$ g
475.                     put_bits(pb, 1, 7);
     
476.                     if (run_size <= 4)
     
477.                     {
     
478.                         /* lengths 2, 3, and 4 are 2 bits */
     
479.                         put_bits(pb, run_size - 2, 2);
     & T% O: g% r! T0 b2 ^0 g7 k0 v" A. O
480.                     }
     
481.                     else if (run_size <= 7)
     5 z& `: H, y7 l  f, v) ?
482.                     {
     - S$ Q. [; D2 [1 _: u" M
483.                         /* lengths 5, 6, and 7 are 4 bits */
     
484.                         put_bits(pb, run_size + 7, 4);
     6 h3 C' q8 M* K/ S( a* h9 Y+ ^
485.                     }
     9 R; x; y' s! Y9 N  {7 M
486.                     else
     0 Y' S" J0 S) M0 j% A  F
487.                     {
     
488.                         /* arbitrary length; start by encoding 0xF which
     ! Y3 _+ {9 U! O' v
489.                          * stands in for an initial version of 8 */
     2 K# T$ ^% c9 w: r% y- I
490.                         put_bits(pb, 0xF, 4);
     
491.                         run_size -= 8;
     
492. 
     
493.                         /* encode blocks of 4 bits until run_size is 0 */
     7 o$ ~7 m- l) D$ O+ b- i
494.                         while (run_size >= 0)
     
495.                         {
     8 G& k- N; h$ i2 W1 t
496.                             if (run_size >= 15)
     
497.                             {
     
498.                                 put_bits(pb, 0xF, 4);
     
499.                                 run_size -= 0xF;
     3 s, B2 m$ \$ _9 N+ c6 K9 K
500.                             }
     
501.                             else
     
502.                             {
     5 w+ q3 o! }4 U5 z+ ^  t  _
503.                                 put_bits(pb, run_size, 4);
     
504.                                 run_size = -1;
     
505.                             }
     
506.                         }
     ( W. }9 X% }0 N3 Q* `1 [3 N. C2 A
507.                     }
     + o  n* P8 _6 X; x' x2 q) ^
508.                 }
     ' E& o4 l2 G& y4 T
509. 
     7 i' o( l1 v5 S9 ~+ F# u( p$ Q0 {
510.                 last_pixel = full_window[x];
     + I. Q  [1 E% y0 U3 ^
511.                 run_size = 1;
     
512. 
     
513.                 /* this single x iteration was only here to close the final run */
     ! T! p4 `/ F; U' Q5 C2 M
514.                 if (y == window_bottom)
     3 {' \3 P5 X: F" ^+ M
515.                     break;
     
516.             }
     
517.         }
     ' O3 I; C# ~8 j
518.     }
     
519. 
     6 w8 w/ H% n3 ^
520.     /* close the bitstream by encoding a back reference with length 0 */
     8 V; \+ a% M) R4 Y3 M
521.     put_bits(pb, 1, 1);  /* back reference run */
     : U+ y6 G$ @# V, ]
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     
523.     put_bits(pb, 0, 7);  /* length 0 */
     
524. 
     
525.     put_bits_flush(pb);
     
526. }
     
527. 
     3 A2 t) e+ n0 g
528. /* compute Euclidean distance between an RGB color and the desired target */
     + r) `- J" c! U5 e! I7 I0 }
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     
530. {
     
531.     return sqrt((r1 - r2) * (r1 - r2) +
     7 ?% p" h+ p" p! p* X* I9 L- U
532.                 (g1 - g2) * (g1 - g2) +
     
533.                 (b1 - b2) * (b1 - b2));
     
534. }
     9 F0 ~1 K6 p5 A. O# ^% u
535. 
     
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     , k, a$ }/ {2 }7 M/ e, P
537. {
     , n* x" e% K8 e( q1 \4 r7 K* h& y
538.     int i;
     
539.     int nearest_distance;
     1 d1 E# @$ d/ r8 S; Q: [- R, {0 A3 P
540.     int distance;
     4 W# x$ \# [! [
541.     int rp;
     
542.     int gp;
     " f0 f/ X1 R0 t& B$ f/ @
543.     int bp;
     
544.     uint8_t palette_index;
     6 r. d. m# y- n+ C+ a! N
545. 
     
546.     nearest_distance = 999999999;
     
547.     palette_index = 0;
     " D( T+ u$ @/ t( D
548.     for (i = 0; i < 256; i++)
     ! I- m. ]. |, e, n. [
549.     {
     1 j/ v. |0 J2 _4 t
550.         rp = rbt->palette[i * 3 + 0];
     
551.         gp = rbt->palette[i * 3 + 1];
     ! t2 J8 `4 H$ @: _5 `
552.         bp = rbt->palette[i * 3 + 2];
     . S4 |' ~( t9 B8 [
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     
554.         if (distance < nearest_distance)
     
555.         {
     3 b! p0 I* g9 C& Y( @: t
556.             nearest_distance = distance;
     2 T* M; S" w1 y
557.             palette_index = i;
     8 y6 i- ~6 b/ j" r" K
558.         }
     
559.         /* can't get closer than 0; break early */
     % ?  J! a+ N3 L, Y: u( @! B; f; A
560.         if (distance == 0)
     0 b6 V, B# t. J' W/ m/ {1 v0 t1 B
561.             break;
     
562.     }
     
563. 
     
564.     return palette_index;
     # Q  u( t1 I. I- G
565. }
     
566. 
     
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     9 U+ z: v) ?6 r- ^* B; ~5 \9 J' G
568.     int width, int height, int timestamp)
     
569. {
     5 t( E" D: s& P
570.     ASS_Image *subtitles;
     
571.     int detect_change;
     
572.     uint8_t subtitle_pixel;
     * Z7 E$ R: G; e2 E3 n2 `' b
573.     int x, y;
     
574.     uint8_t *frame_ptr;
     ( c8 _% N" U/ a6 ^) X' ~9 }
575.     uint8_t *subtitle_ptr;
     * H, P: N6 t/ {' Z" j
576. 
     ; e4 z9 O6 k, q; Z( ]1 Q' h
577.     /* ask library for the subtitle for this timestamp */
     
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     1 ]: h! |6 p5 Q; r! Z6 F
579.         timestamp, &detect_change);
     2 n9 d! O' h$ o- \" `
580. 
     
581.     /* render the list of subtitles onto the decoded frame */
     
582.     while (subtitles)
     
583.     {
     
584.         /* palette components are only 6 bits, so shift an extra 2
     
585.          * bits off each component */
     ( G) N, j, G0 L; ^7 h; X
586.         subtitle_pixel = find_nearest_color(rbt,
     
587.             (subtitles->color >> 10) & 0xFF,
     
588.             (subtitles->color >> 18) & 0xFF,
     # `2 T) z) A5 O/ C" L8 j. U
589.             (subtitles->color >> 26) & 0xFF);
     
590.         for (y = 0; y < subtitles->h; y++)
     " R0 a: X2 T$ l! t# I, c) q
591.         {
     " u, O! g$ L5 h( [+ K5 Y
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     ! a7 e' o) ~4 o+ V
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     
595.             {
     
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     
597.                     *frame_ptr = subtitle_pixel;
     
598.             }
     
599.         }
     ! R& R6 K+ s+ O; p7 [* h8 E
600.         subtitles = subtitles->next;
     
601.     }
     2 O7 C9 r6 J- \, A3 C4 o
602. }
     
603. 
     
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     * x" R0 y# |& b. u2 o
605.     int origin_x, int origin_y, int window_width, int window_height)
     
606. {
     3 c) a. e  S! e% \$ |# b5 q
607.     int i;
     : p% T9 r% f& J, ~/ H1 Q" c
608.     int j;
     
609.     int scale;
     
610.     int width;
     
611.     int height;
     1 h: W: U9 y( z+ H4 U5 {. W
612.     int max_width;
     
613.     int max_height;
     0 _8 ]; S& d. d  F
614.     int frame_x;
     
615.     int frame_y;
     
616.     int fragment_count;
     7 n8 T0 Q. Q) X3 d
617.     int decoded_size;
     % c/ V3 ^8 j" ?& `* V- _
618.     uint8_t *decoded_frame;
     0 j. I3 D) ]1 `
619.     int fragment;
     5 l# Y6 z3 d  a5 F& F* b, W
620.     int fragment_compressed_size;
     2 z# j, k: m  @% c
621.     int fragment_decompressed_size;
     
622.     int compression_type;
     
623.     int index;
       T5 b6 s/ {8 a
624.     int out_index;
     , U8 D$ l' [* l
625.     get_bits_context gb;
     
626.     int frame_size;
     
627.     int video_frame_size;
     
628.     int audio_frame_size;
     
629. 
     , N9 v+ X2 v  I4 s+ o$ z& `
630.     int back_ref_offset_type;
     
631.     int back_ref_offset;
     
632.     int back_ref_length;
     
633.     int back_ref_start;
     
634.     int back_ref_end;
     
635. 
     
636.     uint8_t *full_window;
     
637.     int full_window_size;
     
638.     int y;
     
639.     int window_top;
     
640.     int window_bottom;
     5 l+ V+ r, o0 m. l6 Z; u
641.     int window_left;
     
642.     int window_right;
     6 p5 ~% B1 s( M
643.     int window_size;
     - {7 w: q8 p2 c8 J
644. 
     
645.     char filename[30];
     
646. 
     ; y9 b7 X% K, j0 Q
647.     put_bits_context *pb;
     # ~  x/ n: J8 G- U  g3 P# X: V5 I
648. 
     
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     ( d$ m( a" m" ^# K
651.     pb = init_put_bits();
     
652. 
     4 t) V4 w+ o4 M( }" @
653.     max_width = 0;
     
654.     max_height = 0;
     
655. 
     
656.     for (i = 0; i < rbt->frame_count; i++)
     ; t1 y- ~2 `3 S% f3 P8 c
657.     {
     
658.         /* read the entire frame (includes audio and video) */
     ' U, R. N. N1 T! \, h' ~6 b( Z6 @
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     0 T" Q7 J! ]. V# J0 v$ X# G- ]
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     - t9 q: K* z' C/ Z3 @
661.         audio_frame_size = frame_size - video_frame_size;
     ' M$ q" n( s% M3 N9 b
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     
663.         {
     
664.             printf("problem reading frame %d\n", i);
     
665.             return 0;
     
666.         }
     
667. 
     9 s1 a- Y- A* t; c- b
668.         scale = rbt->frame_load_buffer[3];
     
669.         width = LE_16(&rbt->frame_load_buffer[4]);
       Y" M6 B' r3 x+ Y
670.         if (max_width < width)
     
671.             max_width = width;
     5 p$ I7 o0 N4 M6 e1 d' b
672.         if (max_height < height)
     
673.             max_height = height;
     
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     $ D  @+ i  g/ G/ w1 e
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     7 P" d) y+ T# g4 J
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     2 y+ N' d( |6 `4 }6 g
678.         decoded_size = width * height;
     
679. 
     1 G8 E: N% \2 ^* o5 y1 x
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     ; |; V1 G1 j" {( B
681. 
     
682.         /* decode the frame */
     2 A3 E1 }; d. }3 J( {6 `4 i8 j  T* ]
683.         decoded_frame = malloc(decoded_size);
     
684.         index = 24;
     3 T; {9 f6 ?1 W/ b3 j0 F, ?
685.         out_index = 0;
     
686.         for (fragment = 0; fragment < fragment_count; fragment++)
       L& i: V! [; N. `
687.         {
     % i5 W8 |$ H0 D; g3 n( ^# S
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
689.             index += 4;
     0 l3 m" u8 R3 B& E) B2 }  S/ @' H
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
691.             index += 4;
     
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     ; e' i3 i! |" y* W* V
693.             index += 2;
     / G8 u# D. [' [/ y: T
694. 
     
695.             if (compression_type == 0)
     
696.             {
     
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     
698.                     fragment_compressed_size);
     8 u8 i0 X$ G2 m! B8 K; ]4 O7 z: F, B
699. 
     , Y9 u3 w" l. W$ i- v4 W3 J
700.                 while (out_index < fragment_decompressed_size)
       W; M( W0 n7 y& K
701.                 {
     
702.                     if (read_bits(&gb, 1))
     
703.                     {
     
704.                         /* decode back reference offset type */
     ! j. t7 X2 ?5 ?7 P5 Q
705.                         back_ref_offset_type = read_bits(&gb, 1);
     / u# b: e3 O7 J% X. e6 I
706. 
     3 q$ G  n$ K/ a% s8 x6 c
707.                         /* back reference offset is 7 or 11 bits */
     
708.                         back_ref_offset = read_bits(&gb,
     " a7 ~+ q8 s5 J9 z# q
709.                             (back_ref_offset_type) ? 7 : 11);
     
710. 
     # q/ c+ U/ y% ?8 S$ D$ C' Z: h
711.                         /* get the length of the back reference */
     6 J0 _3 N, P2 `" Y" A
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     & N) C" _3 A5 M) e
713.                         back_ref_start = out_index - back_ref_offset;
     * r0 a7 J1 n: X- D" ]
714.                         back_ref_end = back_ref_start + back_ref_length;
     
715. 
     9 I& G5 C0 ], e: K% t; k4 O
716.                         /* copy the back reference, byte by byte */
     
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     
718.                             decoded_frame[out_index++] = decoded_frame[j];
     . T+ I4 k7 U7 E5 u* u
719.                     }
     . ^0 F+ k: r+ i2 O9 p( A
720.                     else
     
721.                     {
     
722.                         /* read raw pixel byte */
     
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     5 j7 j# H& a% n5 ?1 d/ I/ I0 M
724.                     }
     , r2 h* z- L" M
725.                 }
     9 A" `6 ?' ~  |2 ]
726. 
     
727.                 delete_get_bits(&gb);
     9 m4 K/ i8 {9 u, [
728.             }
     
729. 
     
730.             /* next fragment */
       y1 D& i* L& G% D% F, q
731.             index += fragment_compressed_size;
     
732.         }
     " N8 B: N" Q0 ^% ?# _
733. 
     6 R; W, p% q5 t
734.         if (rbt->dump_frames)
     : d# |+ ~/ L2 v' N- p# d# ?2 p
735.         {
     # ^+ O. r2 B/ c( H; H; r7 y! s- S
736.             /* dump the original frame */
     # _2 L. |+ \$ B& T4 z
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     7 i6 {1 {; `1 R" i  I
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     : T6 T6 x: k5 U1 ?9 e. I- Y
739.         }
     1 v4 s& z7 d  q; [. O) }: ^" N1 F
740. 
     3 F: B* @8 A# R5 C' G/ X4 N
741.         /* transfer the image onto the frame window */
     4 M" s: G0 ~. x! J+ ~
742.         memset(full_window, 0xFF, full_window_size);
     
743.         index = 0;
     $ n6 @, b8 a5 d5 g' {4 f
744.         for (y = 0; y < height; y++)
       L+ z4 [9 r* h
745.         {
     $ M/ j$ E) [8 @! f  }3 P/ m0 P3 D
746.             out_index = window_width * (frame_y + y) + frame_x;
     " D9 }; s0 d- G9 I2 v; M
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
     6 S+ b! \2 @% T* b5 X* r- |
748.             index += width;
     3 V! H# _  N, H  m* L. h8 a
749.         }
     $ Z. U- z; B. x
750. 
     
751.         /* write the subtitle */
     
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     9 X4 F- y# s+ b; q# c
755.         /* figure out the smallest change window */
     ( e+ I- W* J% B1 L: X) f
756.         window_top = frame_y;
     
757.         window_bottom = window_height;
     
758.         window_left = 0;
     
759.         window_right = window_width;
     
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     
761. 
     # Q9 Y& z8 `! d
762.         /* compress the frame */
     
763.         reset_put_bits(pb);
     7 [' A8 ^' y/ r1 K
764.         compress_window(pb, full_window, window_width, window_top,
     4 N7 J. l' g( x, a7 d  G
765.             window_bottom, window_left, window_right);
     
766. 
     ; i% @1 o6 P8 X7 j+ Y: G
767.         if (rbt->dump_frames)
     
768.         {
     
769.             /* dump the frame plotted onto the full window prior to encoding,
     6 C- y) C8 k8 s! [" d2 D9 W- c& F: k
770.              * with subtitle */
     
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     : V6 E7 |4 i8 z/ f$ K0 A
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     
773.         }
     
774. 
     
775.         free(decoded_frame);
     - v( r! `' w( D4 Y* p5 v
776. 
     4 N1 o% n! _/ v/ k; J
777.         /* update the frame header */
     
778.         /* width */
     
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     1 J0 ]$ G' _1 A
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     
781.         /* height */
     
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     1 X9 L7 w1 G4 h3 Z0 i
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     % G+ x5 ?' q4 H% j0 `1 A& ]1 c
784.         /* origin X */
     ' i3 u8 q' a: V4 y
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     6 t  u% F* }2 P$ k( S
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     & t, a- O5 S! t" u9 a2 K) f
787.         /* origin Y */
     / X6 b" d) R; w3 K! F- R9 ?# G
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     
790.         /* fragment payload size */
     
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     ' D1 B# F9 _) {$ ?- U) c: y& s
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     . I# _2 v2 ]6 s% L* H$ r: f
793.         /* fragment count (1) */
     ( I9 M) `  s. N6 p7 y
794.         rbt->frame_load_buffer[18] = 1;
     
795.         rbt->frame_load_buffer[19] = 0;
     
796. 
     
797.         /* update the fragment header */
     
798.         /* compressed size */
     4 f8 u' \+ f& _2 s" q
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     9 q, M! }  x5 {+ O4 X
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     ' O$ \4 f! H. E* h# j
803.         /* decompressed size */
     " O" T% \0 u. ^& C
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     . }4 T  H+ h. b6 P( U! L
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     . v! z% A5 u) b
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     ; b( E* V  C; g5 ?7 {9 a
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     
808.         /* compression format 0 */
     # l" {0 y- F5 d5 l& k: r
809.         rbt->frame_load_buffer[24 + 8] = 0;
     7 [9 d. c7 [4 {: |6 H
810.         rbt->frame_load_buffer[24 + 9] = 0;
     $ _, B5 x0 a$ Q
811. 
     
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     . u- j2 T: _' R+ h' P; h/ l* @% g
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     
814.         {
     4 v% a0 H. p* Q" X& a& f* B
815.             printf("problem writing frame %d\n", i);
     * ?" ?; V/ e. _' X! S
816.             return 0;
     . B( s3 I5 G6 o  F4 s0 L9 s
817.         }
     # t: c% f2 n' K% a
818. 
     
819.         /* write the new compressed frame data */
     
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     4 Q. h8 f7 T$ c/ e+ E: B
821.         {
     
822.             printf("problem writing frame %d\n", i);
     0 G5 G" W% e; S! E, b
823.             return 0;
     
824.         }
     
825. 
     8 G; c" |' H3 P6 `$ T
826.         /* write the audio data */
     - h4 X* r- D8 G5 D2 x
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     
828.         {
     1 \* z. |4 f, I& R8 [/ `1 t8 s+ E
829.             printf("problem writing frame %d\n", i);
     & U  W+ ^# ]/ J. k6 o1 O
830.             return 0;
     
831.         }
     & Y8 _: O* t& l
832. 
     
833.         /* update the table entries */
     
834.         video_frame_size = pb->byte_index + 24 + 10;
     
835.         frame_size = video_frame_size + audio_frame_size;
     
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     ' }" s4 i0 I% [
840.     }
     
841. 
     
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     , n2 E3 f5 U3 B
843. 
     ' }" J9 l9 D  R6 j$ Q" B, |( T
844.     delete_put_bits(pb);
     
845.     free(full_window);
     % M$ x* L2 ^& A% V5 e7 i
846. 
     ' a$ P0 Y0 Q- ~/ @; C5 d
847.     return 1;
     7 z  D+ R4 Z3 Q) o- n/ X+ Q; g
848. }
     ! L9 U  N$ h# i& }4 y4 \. Y
849. 
     
850. int main(int argc, char *argv[])
     ( j% q, b1 Y1 n
851. {
     
852.     char *subtitle_filename;
     
853.     FILE *subtitle_file;
     
854.     char *inrbt_filename;
     
855.     FILE *inrbt_file;
     6 T; K4 ^' x  v( Z
856.     char *outrbt_filename;
     : }$ N  Q" }2 n! [; w5 R6 y
857.     FILE *outrbt_file;
     2 I, O* O. d& ?
858.     rbt_dec_context rbt;
     
859.     int origin_x;
     
860.     int origin_y;
     3 X# ]) w# O1 f9 Z% d+ T
861.     int window_width;
     
862.     int window_height;
     * E4 ^, e! e) P5 v5 J6 b3 C' |
863. 
     % m# C/ j: B& ^- h
864.     /* testing the bit functions */
       P1 K* R* G" P* Y
865. #if 0
     
866.     int i;
     
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     ! q6 n3 F( K! \8 k
868.     int bytestream_size = 10;
     
869.     get_bits_context gb;
     : A2 @) z' r) B! g7 A
870.     put_bits_context *pb;
     
871.     int bits;
     
872. 
     
873.     init_get_bits(&gb, bytestream, bytestream_size);
     ) Z. t# a, x/ A4 B
874.     pb = init_put_bits();
     
875. 
       m& ^/ e! N$ S3 ]& c
876.     for (i = 1; i <= 12; i++)
     
877.     {
     8 Q  w- ]' H7 R+ O% Q
878.         bits = view_bits(&gb, i);
     ' I/ F" v/ L. C9 u: F; e( z9 n3 k
879.         printf("view %d bits: %d\n", i, bits);
     
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     3 E% [( j9 G, y$ @7 m! b
881.         put_bits(pb, bits, i);
     & ~6 _7 v: E  _2 o
882.     }
     
883.     put_bits_flush(pb);
     
884. 
     
885.     printf("original bytestream:\n");
     
886.     for (i = 0; i < bytestream_size; i++)
     $ l, ~3 [! `! g3 M0 m" l! \
887.         printf(" %02X", bytestream[i]);
     4 g  L, Q1 q; `6 c5 N
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     
890.         printf(" %02X", pb->bytes[i]);
     - \& V# t( n8 y& d% Q
891.     printf("\n");
     6 f3 A" F: j0 S% H* T! ?9 j$ @* o& k
892. 
     
893.     delete_get_bits(&gb);
     0 N$ l* s) W  g  n$ o
894.     free(pb);
     
895. #endif
     
896. 
     6 L+ N8 h4 P/ x6 J% V) m& ?) S  H! P
897.     /* validate the number of arguments */
     & {8 B/ @5 X* s0 H
898.     if (argc != 8 && argc != 9)
     
899.     {
     ! c. n  P7 w! y: S) \, I1 ]
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     
901.         return 1;
     
902.     }
     
903.     subtitle_filename = argv[1];
     " M5 u6 c6 y8 M9 O+ l& l
904.     inrbt_filename = argv[2];
     5 z9 T0 e2 L8 ~6 q
905.     outrbt_filename = argv[3];
     . I( U0 y' p, Q7 x. i1 a. `: ^: J
906.     origin_x = atoi(argv[4]);
     
907.     origin_y = atoi(argv[5]);
     " Y/ n1 J! F! T/ O% M: u* L- Y2 d
908.     window_width = atoi(argv[6]);
     * ~  P! v: E4 I. O# g
909.     window_height = atoi(argv[7]);
     9 B  l! x+ C5 g+ `
910.     rbt.dump_frames = 0;
     6 ^. t8 b% g% J8 U& C
911.     if (argc == 9)
     6 p9 R7 m  B" Z) _6 n+ X2 U
912.         rbt.dump_frames = 1;
     , ~6 x4 K2 O' @+ X
913. 
     " k0 x8 \4 K4 Z& e- _
914.     /* verify that the specified input files are valid */
     
915.     subtitle_file = fopen(subtitle_filename, "r");
       p( n& h0 _7 Y9 U
916.     if (!subtitle_file)
     
917.     {
     % |2 k6 i; ^0 E9 y; ~
918.         perror(subtitle_filename);
     - O, D$ _7 Z7 @5 u
919.         return 1;
     
920.     }
     
921.     fclose(subtitle_file);
     
922.     inrbt_file = fopen(inrbt_filename, "rb");
     
923.     if (!inrbt_file)
     
924.     {
     ( Q/ O" `1 _+ T  ?
925.         perror(inrbt_filename);
     
926.         return 1;
     4 J* ^! D' l6 i) Q$ _
927.     }
     . ~% n- o2 ]) g7 h8 s* Y& \7 K6 b
928. 
     
929.     /* initialize the subtitle support */
     
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     % y/ b; Q% k7 q1 F
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     
935. 
     ! X& z' a* a6 {  F
936.     /* open the output file */
     
937.     outrbt_file = fopen(outrbt_filename, "wb");
     
938.     if (!outrbt_file)
     
939.     {
     ( Q, C/ ?- U' \7 b& C
940.         perror(outrbt_filename);
     % i4 ~0 t# `+ _: J
941.         return 1;
     3 @8 J, `" M( O$ J; n
942.     }
     & l# Q- G" x# o% F
943. 
     
944.     /* transfer header from input to output */
     
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     , s+ L: T0 X2 [
946.         return 1;
     # N' [# j+ l/ G& }2 W9 ]1 Q
947. 
     
948.     /* rewrite the frames */
     
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     
950.         window_width, window_height))
     4 q! o( C% ~6 i3 |- ]8 C  N# ]' V
951.         return 1;
     
952. 
     + }( ^0 z' m0 P8 q8 G% e5 D
953.     /* write the modified frame size tables back to the file */
     ; E0 p; N' c$ s: r
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     - @$ n3 R3 [' X% E2 z# o+ b
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     ! h/ @6 G7 p( L- B/ P
958. 
     ( s. a2 G- O# E7 Q: W8 V+ m
959.     /* finished with files */
     0 H# d( K5 O9 m% @, O
960.     fclose(inrbt_file);
     
961.     fclose(outrbt_file);
     0 J4 ?4 \, n; P" Q* i8 R
962. 
     . v0 I7 P; W% f' f! A( k1 I$ F
963.     /* clean up subtitle library */
     1 m: {/ J' ?5 H, x
964.     ass_free_track(rbt.ass_track);
     
965.     ass_renderer_done(rbt.ass_renderer);
     
966.     ass_library_done(rbt.ass_lib);
     
967. 
     
968.     /* clean up */
     0 e$ l6 ^8 p2 K: g7 \
969.     free(rbt.frame_load_buffer);
     8 B7 u3 u/ }3 a( f) s8 a( d
970.     free(rbt.video_frame_size_table);
     8 p& w9 o/ m, d0 W! X% A$ Y. ?
971.     free(rbt.frame_size_table);
     
972. 
     
973.     return 0;
     6 s" w  k. Z- i% ?. @
974. }

复制代码

- j- V/ h0 [) u; z' W* s, r9 Y1 ^
  H( r! ~5 z: z% Y+ G. z: i

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
" l& g, v9 S( X: s7 Y这游戏有字幕吗？

好像没有字幕，我说的是给视频外挂字幕方式的汉化。
& O, e5 K" h6 d1 |* k就像syberia2汉化版下面那行字一样。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
7 s3 S3 @, X6 J' J2 p4 u( x我记得是没字幕的 比较麻烦 都是视频的

给视频外挂字幕方式汉化也许能行。
6 y8 }+ T. l# q5 o要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来